package com.cjx.print.helper;

import android.bluetooth.BluetoothAdapter;

import com.cjx.print.App;
import com.cjx.print.entity.MaterialDetailEntity;
import com.cjx.print.entity.MaterialEntity;
import com.cjx.print.entity.OrderGoodsEntity;
import com.cjx.print.utils.LogUtil;
import com.gengcon.www.jcprintersdk.JCPrintApi;
import com.gengcon.www.jcprintersdk.callback.Callback;
import com.gengcon.www.jcprintersdk.callback.PrintCallback;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


/**
 * create by cjx on 2024/8/17
 * desc: 精臣打印机
 */
public class JCPrinterHelper implements Callback {

    private final JCPrintApi api;
    private boolean connected = false;
    com.cjx.print.interfaces.Callback<Boolean> connectCallback;
    private static final Map<Integer, String> ERROR_MESSAGES = new HashMap<>();

    static {
        ERROR_MESSAGES.put(1, "盒盖打开");
        ERROR_MESSAGES.put(2, "缺纸");
        ERROR_MESSAGES.put(3, "电量不足");
        ERROR_MESSAGES.put(4, "电池异常");
        ERROR_MESSAGES.put(5, "手动停止");
        ERROR_MESSAGES.put(6, "数据错误");
        ERROR_MESSAGES.put(7, "温度过高");
        ERROR_MESSAGES.put(8, "出纸异常");
        ERROR_MESSAGES.put(9, "正在打印");
        ERROR_MESSAGES.put(10, "没有检测到打印头");
        ERROR_MESSAGES.put(11, "环境温度过低");
        ERROR_MESSAGES.put(12, "打印头未锁紧");
        ERROR_MESSAGES.put(13, "未检测到碳带");
        ERROR_MESSAGES.put(14, "不匹配的碳带");
        ERROR_MESSAGES.put(15, "用完的碳带");
        ERROR_MESSAGES.put(16, "不支持的纸张类型");
        ERROR_MESSAGES.put(17, "纸张类型设置失败");
        ERROR_MESSAGES.put(18, "打印模式设置失败");
        ERROR_MESSAGES.put(19, "设置浓度失败");
        ERROR_MESSAGES.put(20, "写入rfid失败");
        ERROR_MESSAGES.put(21, "边距设置失败");
        ERROR_MESSAGES.put(22, "通讯异常");
        ERROR_MESSAGES.put(23, "打印机连接断开");
        ERROR_MESSAGES.put(24, "画板参数错误");
        ERROR_MESSAGES.put(25, "旋转角度错误");
        ERROR_MESSAGES.put(26, "json参数错误");
        ERROR_MESSAGES.put(27, "出纸异常(B3S)");
        ERROR_MESSAGES.put(28, "检查纸张类型");
        ERROR_MESSAGES.put(29, "RFID标签未进行写入操作");
        ERROR_MESSAGES.put(30, "不支持浓度设置");
        ERROR_MESSAGES.put(31, "不支持的打印模式");
    }

    private static final class HelperHolder {
        static final JCPrinterHelper helper = new JCPrinterHelper();
    }

    public static JCPrinterHelper getInstance() {
        return HelperHolder.helper;
    }

    private JCPrinterHelper() {

        api = JCPrintApi.getInstance(this);
        try {
            boolean initResult = api.initSdk(App.app);
            int settingResult = api.initDefaultImageLibrarySettings("", "");
            log(" >> initResult = " + initResult + ", settingResult = " + settingResult);
        } catch (Exception | Error e) {
            e.printStackTrace();
        }

    }

    /**
     * 连接成功回调
     *
     * @param address 设备地址，蓝⽛为蓝⽛ MAC 地址，WIFI 为 IP 地址
     * @param type    连接类型，0 表示蓝⽛连接，1 表示 WIFI 连接
     */
    @Override
    public void onConnectSuccess(String address, int type) {
        connected = true;
        if (connectCallback != null) {
            connectCallback.callback(true);
        }
        log(" >> 打印机连接 " + address + ", " + type);
    }

    /**
     * 断开连接回调
     * 当设备断开连接时，将调⽤此⽅法。
     */
    @Override
    public void onDisConnect() {
        if (connectCallback != null) {
            connectCallback.callback(false);
        }
        log(" >> 打印机断开 ");
        connected = false;
        BluetoothAdapter.getDefaultAdapter().startDiscovery();
    }

    /**
     * 电量变化回调
     * 当设备电量发⽣变化时，将调⽤此⽅法。
     *
     * @param powerLevel 电量等级，取值范围为 1 到 4，代表有 1 到 4 格电，满电是 4 格
     */
    @Override
    public void onElectricityChange(int powerLevel) {
        log(" >> onElectricityChange " + powerLevel);
    }

    /**
     * 监测上盖状态变化回调
     * 当上盖状态发⽣变化时，将调⽤此⽅法。⽬前该回调仅⽀持 H10/D101/D110/D11/B21/B16/
     * B32/Z401/B3S/B203/B1/B18 系列打印机。
     *
     * @param coverStatus 上盖状态，0 表示上盖打开，1 表示上盖关闭
     */
    @Override
    public void onCoverStatus(int coverStatus) {
        log(" >> onCoverStatus " + coverStatus);
    }

    /**
     * 监测纸张状态变化
     * 当纸张状态发⽣变化时，将调⽤此⽅法。⽬前该回调仅⽀持H10/D101/D110/D11/B21/B16/B
     * 32/Z401/B203/B1/B18 系列打印机。
     *
     * @param paperStatus 0为不缺纸 1为缺纸
     */
    @Override
    public void onPaperStatus(int paperStatus) {
        log(" >> onPaperStatus " + paperStatus);
    }

    /**
     * 监测标签rfid读取状态变化
     * 当标签rfid读取状态发⽣变化时，将调⽤此⽅法。
     *
     * @param rfidReadStatus 0为未读取到标签RFID 1为成功读取到标签RFID ⽬前该回调仅⽀
     *                       持H10/D101/D110/D11/B21/B16/B32/Z401/B203/B1/B18 系列打印机。
     */
    @Override
    public void onRfidReadStatus(int rfidReadStatus) {
        log(" >> onRfidReadStatus " + rfidReadStatus);
    }

    /**
     * 监测碳带rfid读取状态变化
     * 当碳带rfid读取状态发⽣变化时，将调⽤此⽅法。
     *
     * @param ribbonRfidReadStatus 0为未读取到碳带RFID 1为成功读取到碳带RFID ⽬前该
     *                             回调仅⽀持B18/B32/Z401/P1/P1S 系列打印机。
     */
    @Override
    public void onRibbonRfidReadStatus(int ribbonRfidReadStatus) {
        log(" >> onRibbonRfidReadStatus " + ribbonRfidReadStatus);
    }

    /**
     * 监测碳带状态变化
     * 当纸张状态发⽣变化时，将调⽤此⽅法
     *
     * @param ribbonStatus 0为⽆碳带 1为有碳带 ⽬前该回调仅⽀持B18/B32/Z401/P1/P1S
     *                     系列打印机。
     */
    @Override
    public void onRibbonStatus(int ribbonStatus) {
        log(" >> onRibbonStatus " + ribbonStatus);
    }

    /**
     * 固件异常回调，需要升级
     * 当设备连接成功但出现固件异常时，将调⽤此⽅法，表示需要进⾏固件升级。
     */
    @Override
    public void onFirmErrors() {
        log(" >> onFirmErrors ");
    }

    public void connectDevice(final String address, final int delay, com.cjx.print.interfaces.Callback<Boolean> connectCallback) {
        this.connectCallback = connectCallback;
        new Thread(() -> {
            log(" >> 连接设备：" + address);
            try {
                Thread.sleep(delay);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            int result = api.connectBluetoothPrinter(address);
            log(" >> 连接设备结果：" + result);
        }).start();
    }

    public void disconnect() {
        api.close();
    }

    /**
     * 打印模式 1=热敏 2=热转印
     */
    private final int printMode = 1;

    /**
     * 打印浓度
     */
    private final int printDensity = 3;

    int generatedPrintDataPageCount;
    /**
     * 打印页数
     */
    int pageCount;
    /**
     * 打印份数
     */
    int quantity;

    /**
     * 是否打印错误
     */
    private boolean isError;
    /**
     * 是否取消打印
     */
    private boolean isCancel;

    /**
     * 图像数据
     */
    private ArrayList<String> jsonList = new ArrayList<>();
    /**
     * 图像处理数据
     */
    private ArrayList<String> infoList = new ArrayList<>();

    private void log(String message) {
        LogUtil.getInstance().log("PRINT", message);
    }

    // 打印订单
    public void printOrderLabel(int serial, String time, ArrayList<OrderGoodsEntity> goodsList) {
        print(goodsList.size(), i -> {
            OrderGoodsEntity goods = goodsList.get(i - 1);
            String specName = goods.getSpecName() == null ? "" : goods.getSpecName();
            generateOrderPrintData(serial, goods.getGoodsName(), specName,
                    time, goods.getQrCode());
        });
    }

    // 打印配方标签
    public void printFormulaLabel(String goodsName, String specName, String productNumber) {
        print(1, data -> generateFormulaPrintData(goodsName, specName, productNumber));
    }

    // 打印物料标签
    public void printMaterialTag(MaterialEntity material) {
        if (material.isMerge() || material.getList().size() < 2) {
            print(1, i -> generateMaterialTagPrintData(material));
        } else {
            print(material.getList().size(), i -> {
                MaterialDetailEntity materialDetailEntity = material.getList().get(i - 1);
                List<MaterialDetailEntity> singletonList = Collections.singletonList(materialDetailEntity);
                MaterialEntity m = new MaterialEntity(material.getTitle(), material.getDescribe(), singletonList);
                generateMaterialTagPrintData(m);
            });
        }
    }

    // 生成订单信息的打印数据
    private void generateOrderPrintData(int serial, String goodsName, String specName, String time, String qrCode) {
        DecimalFormat serialFormat = new DecimalFormat("0000");
        String serialNumber = serialFormat.format(serial);
        api.drawLabelText(
                0f, 1.6f, 40f, 3.2f, // x, y, 宽, 高
                serialNumber + "-" + goodsName, "", 3.2f, 0,// 内容, 字体, 字体大小, 角度
                1, 1, // 水平对齐, 垂直对齐 (0-左/上对⻬，1-居中对⻬，2-右/下对⻬)
                4,  // 行模式, 1-宽⾼固定，内容⼤⼩⾃适应，2-宽度固定，⾼度⾃适应，3-宽⾼固定，超出内容⽤省略号表示，4-宽⾼固定，超出内容直接裁切，6-宽⾼固定，内容超过预设的宽⾼时⾃动缩⼩
                0, 1, // 字⺟之间的标准间隔, ⾏间距
                new boolean[]{false, false, false, false} // 字体样式，数组⻓度为4，依次表示：加粗（⽣效），斜体（⽣效），下划线（⽣效），删除线（暂不⽣效）
        );
        api.drawLabelText(
                0f, 6.2f, 40f, 3.0f, // x, y, 宽, 高
                specName, "", 2.8f, 0,// 内容, 字体, 字体大小, 角度
                1, 1, // 水平对齐, 垂直对齐 (0-左/上对⻬，1-居中对⻬，2-右/下对⻬)
                4,  // 行模式, 1-宽⾼固定，内容⼤⼩⾃适应，2-宽度固定，⾼度⾃适应，3-宽⾼固定，超出内容⽤省略号表示，4-宽⾼固定，超出内容直接裁切，6-宽⾼固定，内容超过预设的宽⾼时⾃动缩⼩
                0, 1, // 字⺟之间的标准间隔, ⾏间距
                new boolean[]{false, false, false, false} // 字体样式，数组⻓度为4，依次表示：加粗（⽣效），斜体（⽣效），下划线（⽣效），删除线（暂不⽣效）
        );
        api.drawLabelQrCode(
                12.5f, 10.4f, 15f, 15f, // x, y, 宽, 高
                qrCode, 31, // 内容, 类型 31-QR_CODE，32-PDF417，33-DATA_MATRIX，34-AZTEC
                0 // 角度
        );
        api.drawLabelText(
                1.4f, 26.1f, 40f, 3.0f, // x, y, 宽, 高
                time, "", 2.8f, 0,// 内容, 字体, 字体大小, 角度
                1, 1, // 水平对齐, 垂直对齐 (0-左/上对⻬，1-居中对⻬，2-右/下对⻬)
                4,  // 行模式, 1-宽⾼固定，内容⼤⼩⾃适应，2-宽度固定，⾼度⾃适应，3-宽⾼固定，超出内容⽤省略号表示，4-宽⾼固定，超出内容直接裁切，6-宽⾼固定，内容超过预设的宽⾼时⾃动缩⼩
                0, 1, // 字⺟之间的标准间隔, ⾏间距
                new boolean[]{false, false, false, false} // 字体样式，数组⻓度为4，依次表示：加粗（⽣效），斜体（⽣效），下划线（⽣效），删除线（暂不⽣效）
        );
    }

    // 生成配方信息的打印数据
    private void generateFormulaPrintData(String goodsName, String specName, String qrCode) {
        api.drawLabelText(
                0f, 1.6f, 40f, 3.5f, // x, y, 宽, 高
                goodsName, "", 3.5f, 0,// 内容, 字体, 字体大小, 角度
                1, 1, // 水平对齐, 垂直对齐 (0-左/上对⻬，1-居中对⻬，2-右/下对⻬)
                4,  // 行模式, 1-宽⾼固定，内容⼤⼩⾃适应，2-宽度固定，⾼度⾃适应，3-宽⾼固定，超出内容⽤省略号表示，4-宽⾼固定，超出内容直接裁切，6-宽⾼固定，内容超过预设的宽⾼时⾃动缩⼩
                0, 1, // 字⺟之间的标准间隔, ⾏间距
                new boolean[]{false, false, false, false} // 字体样式，数组⻓度为4，依次表示：加粗（⽣效），斜体（⽣效），下划线（⽣效），删除线（暂不⽣效）
        );
        api.drawLabelText(
                0f, 6.6f, 40f, 3.0f, // x, y, 宽, 高
                specName, "", 2.8f, 0,// 内容, 字体, 字体大小, 角度
                1, 1, // 水平对齐, 垂直对齐 (0-左/上对⻬，1-居中对⻬，2-右/下对⻬)
                4,  // 行模式, 1-宽⾼固定，内容⼤⼩⾃适应，2-宽度固定，⾼度⾃适应，3-宽⾼固定，超出内容⽤省略号表示，4-宽⾼固定，超出内容直接裁切，6-宽⾼固定，内容超过预设的宽⾼时⾃动缩⼩
                0, 1, // 字⺟之间的标准间隔, ⾏间距
                new boolean[]{false, false, false, false} // 字体样式，数组⻓度为4，依次表示：加粗（⽣效），斜体（⽣效），下划线（⽣效），删除线（暂不⽣效）
        );
        api.drawLabelQrCode(
                12.6f, 11.4f, 15f, 15f, // x, y, 宽, 高
                qrCode, 31, // 内容, 类型 31-QR_CODE，32-PDF417，33-DATA_MATRIX，34-AZTEC
                0 // 角度
        );
    }


    private void generateMaterialTagPrintData(MaterialEntity material) {
        api.drawLabelText(
                0f, 0.3f, 40f, 4.0f, // x, y, 宽, 高
                material.getTitle(), "", 4.0f, 0,// 内容, 字体, 字体大小, 角度
                1, 1, // 水平对齐, 垂直对齐 (0-左/上对⻬，1-居中对⻬，2-右/下对⻬)
                1,  // 行模式, 1-宽⾼固定，内容⼤⼩⾃适应，2-宽度固定，⾼度⾃适应，3-宽⾼固定，超出内容⽤省略号表示，4-宽⾼固定，超出内容直接裁切，6-宽⾼固定，内容超过预设的宽⾼时⾃动缩⼩
                0, 1, // 字⺟之间的标准间隔, ⾏间距
                new boolean[]{false, false, false, false} // 字体样式，数组⻓度为4，依次表示：加粗（⽣效），斜体（⽣效），下划线（⽣效），删除线（暂不⽣效）
        );
        api.drawLabelText(
                0f, 4.5f, 40f, 3.5f, // x, y, 宽, 高
                material.getDescribe(), "", 3.5f, 0,// 内容, 字体, 字体大小, 角度
                1, 1, // 水平对齐, 垂直对齐 (0-左/上对⻬，1-居中对⻬，2-右/下对⻬)
                1,  // 行模式, 1-宽⾼固定，内容⼤⼩⾃适应，2-宽度固定，⾼度⾃适应，3-宽⾼固定，超出内容⽤省略号表示，4-宽⾼固定，超出内容直接裁切，6-宽⾼固定，内容超过预设的宽⾼时⾃动缩⼩
                0, 1, // 字⺟之间的标准间隔, ⾏间距
                new boolean[]{false, false, false, false} // 字体样式，数组⻓度为4，依次表示：加粗（⽣效），斜体（⽣效），下划线（⽣效），删除线（暂不⽣效）
        );
        float lineWidth = 0.3f;
        float x = 0.5f;
        float y = 8.3f;
        float width = 39f;
        float height = 18f;
        api.drawLabelGraph(x, y, width, height, // x, y, 宽, 高
                3, // 图形类型，可选值：1-圆，2-椭圆，3-矩形，4-圆⻆矩形
                0, 0, // 旋转⻆度，可选值：0、90、180、270 , 圆角半径
                lineWidth, 1, new float[]{}); // 线宽，单位：毫⽶ ， 线条类型，可选值：1-实线，2-虚线类型（虚实⽐例1:1） ， 虚线样式，数组中包含实线段⻓度和空线段⻓度
        float itemHeight = (height - 4 * lineWidth) / 4f;
        float firstWidth = 18f;
        float lastWidth = 7f;
        float centerItemWidth = width - x - firstWidth - lastWidth - 3 * lineWidth;
        for (int i = 1; i < 4; i++) {
            api.drawLabelLine(x, y + i * (itemHeight + lineWidth), width, lineWidth, // x, y, 宽, 高
                    0, 1, new float[]{});// 旋转⻆度，可选值：0、90、180、270 , 线条类型，可选值：1-实线，2-虚线类型（虚实⽐例1:1） , 虚线样式，数组中包含实线段⻓度和空线段⻓度
        }
        api.drawLabelLine(firstWidth + lineWidth, y, lineWidth, height, // x, y, 宽, 高
                0, 1, new float[]{});// 旋转⻆度，可选值：0、90、180、270 , 线条类型，可选值：1-实线，2-虚线类型（虚实⽐例1:1） , 虚线样式，数组中包含实线段⻓度和空线段⻓度
        api.drawLabelLine(firstWidth + 2 * lineWidth + centerItemWidth, y, lineWidth, height, // x, y, 宽, 高
                0, 1, new float[]{});// 旋转⻆度，可选值：0、90、180、270 , 线条类型，可选值：1-实线，2-虚线类型（虚实⽐例1:1） , 虚线样式，数组中包含实线段⻓度和空线段⻓度
        int index = 0;
        for (MaterialDetailEntity detail : material.getList()) {
            float bodyY = y + lineWidth + index * (itemHeight + lineWidth);
            index++;
            api.drawLabelText(
                    x + lineWidth, bodyY, firstWidth, itemHeight, // x, y, 宽, 高
                    detail.getName(), "", 4f, 0,// 内容, 字体, 字体大小, 角度
                    1, 1, // 水平对齐, 垂直对齐 (0-左/上对⻬，1-居中对⻬，2-右/下对⻬)
                    6,  // 行模式, 1-宽⾼固定，内容⼤⼩⾃适应，2-宽度固定，⾼度⾃适应，3-宽⾼固定，超出内容⽤省略号表示，4-宽⾼固定，超出内容直接裁切，6-宽⾼固定，内容超过预设的宽⾼时⾃动缩⼩
                    0, 1, // 字⺟之间的标准间隔, ⾏间距
                    new boolean[]{false, false, false, false} // 字体样式，数组⻓度为4，依次表示：加粗（⽣效），斜体（⽣效），下划线（⽣效），删除线（暂不⽣效）
            );
            api.drawLabelText(
                    x + 2 * lineWidth + firstWidth, bodyY, centerItemWidth, itemHeight, // x, y, 宽, 高
                    detail.getSpec(), "", 4f, 0,// 内容, 字体, 字体大小, 角度
                    1, 1, // 水平对齐, 垂直对齐 (0-左/上对⻬，1-居中对⻬，2-右/下对⻬)
                    6,  // 行模式, 1-宽⾼固定，内容⼤⼩⾃适应，2-宽度固定，⾼度⾃适应，3-宽⾼固定，超出内容⽤省略号表示，4-宽⾼固定，超出内容直接裁切，6-宽⾼固定，内容超过预设的宽⾼时⾃动缩⼩
                    0, 1, // 字⺟之间的标准间隔, ⾏间距
                    new boolean[]{false, false, false, false} // 字体样式，数组⻓度为4，依次表示：加粗（⽣效），斜体（⽣效），下划线（⽣效），删除线（暂不⽣效）
            );
            api.drawLabelText(
                    x + 3 * lineWidth + firstWidth + centerItemWidth, bodyY, lastWidth, itemHeight, // x, y, 宽, 高
                    detail.getQuantity(), "", 4f, 0,// 内容, 字体, 字体大小, 角度
                    1, 1, // 水平对齐, 垂直对齐 (0-左/上对⻬，1-居中对⻬，2-右/下对⻬)
                    6,  // 行模式, 1-宽⾼固定，内容⼤⼩⾃适应，2-宽度固定，⾼度⾃适应，3-宽⾼固定，超出内容⽤省略号表示，4-宽⾼固定，超出内容直接裁切，6-宽⾼固定，内容超过预设的宽⾼时⾃动缩⼩
                    0, 1, // 字⺟之间的标准间隔, ⾏间距
                    new boolean[]{false, false, false, false} // 字体样式，数组⻓度为4，依次表示：加粗（⽣效），斜体（⽣效），下划线（⽣效），删除线（暂不⽣效）
            );
        }
    }

    private void print(int pageCount, com.cjx.print.interfaces.Callback<Integer> generateCallback) {
        if (!connected) {
            log(" >> 打印机未连接");
            return;
        }
        // 重置错误和取消打印状态
        isError = false;
        isCancel = false;
        // 在每次打印任务前初始化生成的打印数据页数
        generatedPrintDataPageCount = 0;
        // 设置打印的总页数和份数
        quantity = 1;
        this.pageCount = pageCount;
        int totalQuantity = pageCount * quantity;
        /*
         * 该方法用于设置要打印的总份数。表示所有页面的打印份数之和。
         * 例如，如果你有3页需要打印，第一页打印3份，第二页打印2份，第三页打印5份，那么总打印份数的值应为10（3+2+5）
         */
        api.setTotalPrintQuantity(totalQuantity);
        // 浓度(B3S默认3)、纸张类型(1:间隙纸; 2:⿊标纸; 3:连续纸; 4:定孔纸; 5:透明纸; 6:标牌)、打印模式(1热敏，2热转印)
        api.startPrintJob(printDensity, 1, printMode, new PrintCallback() {
            @Override
            public void onProgress(int pageIndex, int quantityIndex, HashMap<String, Object> hashMap) {
                //pageIndex为打印页码进度，quantityIndex为打印份数进度，如第二页第三份
                // 更新打印进度
                String progressMessage = "打印进度:已打印到第" + pageIndex + "页,第" + quantityIndex + "份";

                log(" >> " + progressMessage);
                // 处理打印完成情况
                if (pageIndex == pageCount && quantityIndex == quantity) {
                    log(" >>  结束打印");
                    //endJob，使用方法含义更明确的endPrintJob
                    api.endPrintJob();
                }
            }

            @Override
            public void onError(int code) {
                isError = true;
                api.endPrintJob();
                log(" >> 打印报错1：" + ERROR_MESSAGES.get(code));
            }

            @Override
            public void onError(int errorCode, int printState) {
                isError = true;
                api.endPrintJob();
                log(" >> 打印报错2：" + ERROR_MESSAGES.get(errorCode));
            }

            @Override
            public void onCancelJob(boolean b) {
                isCancel = true;
                log(" >> 取消打印");
            }

            @Override
            public void onBufferFree(int pageIndex, int bufferSize) {
                /*
                 * 1.如果未结束打印，且SDK缓存出现空闲，则自动回调该接口，此回调会上报多次，直到打印结束。
                 * 2.打印过程中，如果出现错误、取消打印，或 pageIndex 超过总页数，则返回。(此处控制代码必须得保留，否则会导致打印失败)
                 */
                if (isError || isCancel || pageIndex > pageCount) {
                    return;
                }
                jsonList.clear();
                infoList.clear();
                // 生成数据
                int canvasWidth = 40;
                int canvasHeight = 30;
                int orientation = 0;
                // 设置画布大小
                api.drawEmptyLabel(canvasWidth, canvasHeight, orientation, new ArrayList<>());
                generateCallback.callback(pageIndex);
                //生成打印数据
                byte[] jsonByte = api.generateLabelJson();
                //转换为jsonStr
                String jsonStr = new String(jsonByte);
                jsonList.add(jsonStr);

                infoList.add("{\"printerImageProcessingInfo\":{\"verticalOffset\":0,\"printQuantity\":1,\"printMultiple\":8,\"height\":30,\"width\":40,\"margin\":[0,0,0,0],\"epc\":\"\",\"orientation\":0,\"horizontalOffset\":0}}");
                // 提交打印数据
                api.commitData(jsonList, infoList);
            }
        });
    }
}
